package config

import (
	"fmt"
	"os"
	"path/filepath"

	"gopkg.in/yaml.v3"
)

// Config 主配置结构
type Config struct {
	HTTP     *HTTPConfig     `yaml:"http" json:"http"`
	Vector   *VectorConfig   `yaml:"vector" json:"vector"`
	Document *DocumentConfig `yaml:"document" json:"document"`
	Log      *LogConfig      `yaml:"log" json:"log"`
}

// HTTPConfig HTTP服务配置
type HTTPConfig struct {
	Port             int    `yaml:"port" json:"port"`
	Host             string `yaml:"host" json:"host"`
	AutoScan         bool   `yaml:"auto_scan" json:"auto_scan"`
	ScanRange        int    `yaml:"scan_range" json:"scan_range"`
	CheckTimeout     int    `yaml:"check_timeout" json:"check_timeout"`
	MaxConcurrent    int    `yaml:"max_concurrent" json:"max_concurrent"`
	StreamBufferSize int    `yaml:"stream_buffer_size" json:"stream_buffer_size"`
}

// VectorConfig 向量数据库配置
type VectorConfig struct {
	DataPath           string `yaml:"data_path" json:"data_path"`
	AutoUpdateInterval int    `yaml:"auto_update_interval" json:"auto_update_interval"`
	BatchSize          int    `yaml:"batch_size" json:"batch_size"`
}

// DocumentConfig 文档处理配置
type DocumentConfig struct {
	KnowledgeBasePath string   `yaml:"knowledge_base_path" json:"knowledge_base_path"`
	SupportedFormats  []string `yaml:"supported_formats" json:"supported_formats"`
	ChunkSize         int      `yaml:"chunk_size" json:"chunk_size"`
}

// LogConfig 日志配置
type LogConfig struct {
	Level    string `yaml:"level" json:"level"`
	FilePath string `yaml:"file_path" json:"file_path"`
	MaxSize  int    `yaml:"max_size" json:"max_size"`
}

// DefaultConfig 创建默认配置
func DefaultConfig() *Config {
	return &Config{
		HTTP: &HTTPConfig{
			Port:             8765,
			Host:             "localhost",
			AutoScan:         true,
			ScanRange:        10,
			CheckTimeout:     3,
			MaxConcurrent:    10,
			StreamBufferSize: 4096,
		},
		Vector: &VectorConfig{
			DataPath:           "",
			AutoUpdateInterval: 5,
			BatchSize:          10,
		},
		Document: &DocumentConfig{
			KnowledgeBasePath: "",
			SupportedFormats:  []string{".md", ".txt", ".pdf", ".docx"},
			ChunkSize:         1000,
		},
		Log: &LogConfig{
			Level:    "info",
			FilePath: "mcp-server.log",
			MaxSize:  100,
		},
	}
}

// ConfigManager 配置管理器
type ConfigManager struct {
	configPath string
	config     *Config
}

// NewConfigManager 创建配置管理器
func NewConfigManager(configPath string) *ConfigManager {
	return &ConfigManager{
		configPath: configPath,
		config:     DefaultConfig(),
	}
}

// LoadConfig 加载配置文件
func (cm *ConfigManager) LoadConfig() error {
	// 如果配置文件不存在，创建默认配置文件
	if !cm.configExists() {
		fmt.Printf("[INFO] 配置文件不存在，创建默认配置: %s\n", cm.configPath)
		return cm.SaveConfig()
	}

	// 读取配置文件
	data, err := os.ReadFile(cm.configPath)
	if err != nil {
		return fmt.Errorf("读取配置文件失败: %w", err)
	}

	// 解析YAML
	config := DefaultConfig()
	if err := yaml.Unmarshal(data, config); err != nil {
		return fmt.Errorf("解析配置文件失败: %w", err)
	}

	// 验证配置
	if err := cm.validateConfig(config); err != nil {
		return fmt.Errorf("配置验证失败: %w", err)
	}

	cm.config = config
	fmt.Printf("[SUCCESS] 配置文件加载成功: %s\n", cm.configPath)
	return nil
}

// SaveConfig 保存配置文件
func (cm *ConfigManager) SaveConfig() error {
	// 确保目录存在
	dir := filepath.Dir(cm.configPath)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return fmt.Errorf("创建配置目录失败: %w", err)
	}

	// 序列化为YAML
	data, err := yaml.Marshal(cm.config)
	if err != nil {
		return fmt.Errorf("序列化配置失败: %w", err)
	}

	// 写入文件
	if err := os.WriteFile(cm.configPath, data, 0644); err != nil {
		return fmt.Errorf("写入配置文件失败: %w", err)
	}

	fmt.Printf("[SUCCESS] 配置文件保存成功: %s\n", cm.configPath)
	return nil
}

// GetConfig 获取配置
func (cm *ConfigManager) GetConfig() *Config {
	return cm.config
}

// UpdateHTTPPort 更新HTTP端口配置
func (cm *ConfigManager) UpdateHTTPPort(port int) error {
	if port < 1 || port > 65535 {
		return fmt.Errorf("端口号必须在 1-65535 范围内")
	}

	cm.config.HTTP.Port = port
	return cm.SaveConfig()
}

// configExists 检查配置文件是否存在
func (cm *ConfigManager) configExists() bool {
	_, err := os.Stat(cm.configPath)
	return err == nil
}

// validateConfig 验证配置
func (cm *ConfigManager) validateConfig(config *Config) error {
	// 验证HTTP配置
	if config.HTTP != nil {
		if config.HTTP.Port < 1 || config.HTTP.Port > 65535 {
			return fmt.Errorf("HTTP端口号必须在 1-65535 范围内: %d", config.HTTP.Port)
		}
		if config.HTTP.ScanRange < 1 || config.HTTP.ScanRange > 100 {
			return fmt.Errorf("端口扫描范围必须在 1-100 之间: %d", config.HTTP.ScanRange)
		}
		if config.HTTP.CheckTimeout < 1 || config.HTTP.CheckTimeout > 30 {
			return fmt.Errorf("端口检查超时必须在 1-30 秒之间: %d", config.HTTP.CheckTimeout)
		}
	}

	// 验证向量配置
	if config.Vector != nil {
		if config.Vector.AutoUpdateInterval < 1 {
			return fmt.Errorf("自动更新间隔必须大于0: %d", config.Vector.AutoUpdateInterval)
		}
		if config.Vector.BatchSize < 1 || config.Vector.BatchSize > 1000 {
			return fmt.Errorf("批处理大小必须在 1-1000 之间: %d", config.Vector.BatchSize)
		}
	}

	return nil
}

// GetConfigPath 获取配置文件路径
func (cm *ConfigManager) GetConfigPath() string {
	return cm.configPath
}

// ReloadConfig 重新加载配置
func (cm *ConfigManager) ReloadConfig() error {
	fmt.Println("[INFO] 重新加载配置文件...")
	return cm.LoadConfig()
}

// GetHTTPConfig 获取HTTP配置
func (cm *ConfigManager) GetHTTPConfig() *HTTPConfig {
	if cm.config != nil && cm.config.HTTP != nil {
		return cm.config.HTTP
	}
	return DefaultConfig().HTTP
}

// GetVectorConfig 获取向量配置
func (cm *ConfigManager) GetVectorConfig() *VectorConfig {
	if cm.config != nil && cm.config.Vector != nil {
		return cm.config.Vector
	}
	return DefaultConfig().Vector
}

// GetDocumentConfig 获取文档配置
func (cm *ConfigManager) GetDocumentConfig() *DocumentConfig {
	if cm.config != nil && cm.config.Document != nil {
		return cm.config.Document
	}
	return DefaultConfig().Document
}

// PrintConfig 打印当前配置
func (cm *ConfigManager) PrintConfig() {
	fmt.Println("=== 当前配置 ===")
	fmt.Printf("配置文件: %s\n", cm.configPath)

	if cm.config.HTTP != nil {
		fmt.Printf("HTTP端口: %d\n", cm.config.HTTP.Port)
		fmt.Printf("HTTP主机: %s\n", cm.config.HTTP.Host)
		fmt.Printf("自动扫描: %v\n", cm.config.HTTP.AutoScan)
		fmt.Printf("扫描范围: %d\n", cm.config.HTTP.ScanRange)
	}

	if cm.config.Vector != nil {
		fmt.Printf("向量数据路径: %s\n", cm.config.Vector.DataPath)
		fmt.Printf("自动更新间隔: %d分钟\n", cm.config.Vector.AutoUpdateInterval)
	}

	if cm.config.Document != nil {
		fmt.Printf("知识库路径: %s\n", cm.config.Document.KnowledgeBasePath)
		fmt.Printf("支持格式: %v\n", cm.config.Document.SupportedFormats)
	}
}
